home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / libx11 / libx11 / x11text.c < prev    next >
C/C++ Source or Header  |  1999-01-01  |  14KB  |  497 lines
  1. /* Copyright (c) 1996 by Terje Pedersen.  All Rights Reserved   */
  2. /*                                                              */
  3. /* By using this code you will agree to these terms:            */
  4. /*                                                              */
  5. /* 1. You may not use this code for profit in any way or form   */
  6. /*    unless an agreement with the author has been reached.     */
  7. /*                                                              */
  8. /* 2. The author is not responsible for any damages caused by   */
  9. /*    the use of this code.                                     */
  10. /*                                                              */
  11. /* 3. All modifications are to be released to the public.       */
  12. /*                                                              */
  13. /* Thats it! Have fun!                                          */
  14. /* TP                                                           */
  15. /*                                                              */
  16.  
  17. /***
  18.    NAME
  19.      text
  20.    PURPOSE
  21.      text drawing functions
  22.    NOTES
  23.      
  24.    HISTORY
  25.      Terje Pedersen - Mar 21, 1995: Created.
  26.  
  27. 7. Nov 96: Added comment headers to all functions and cleaned the code up
  28.            somewhat. If you have the manual pages you may notice an eerie
  29.        similarity..
  30. ***/
  31.  
  32. #include "amiga.h"
  33. #include "libX11.h"
  34.  
  35. /*#define XLIB_ILLEGAL_ACCESS 1*/
  36.  
  37. #include <X11/Xutil.h>
  38. #include <X11/Intrinsic.h>
  39. #include <X11/IntrinsicP.h>
  40. #include <X11/CoreP.h>
  41.  
  42. #include <X11/Xlibint.h>
  43.  
  44. #include "x11display.h"
  45. #include "x11text.h"
  46.  
  47. /********************************************************************************/
  48. /* external */
  49. /********************************************************************************/
  50.  
  51. extern int X11muiapp;
  52. extern int X11FunctionMapping[];
  53.  
  54. /********************************************************************************/
  55. /* internal */
  56. /********************************************************************************/
  57.  
  58. #ifdef DEBUGXEMUL_ENTRY
  59. int bIgnoreText = 1; /* ignore outputting information about text */
  60. int bSkipText = 0;
  61. #endif
  62.  
  63. /********************************************************************************
  64. Function : XDrawString()
  65. Author   : Terje Pedersen
  66. Input    : 
  67.      display   Specifies  a  connection  to  an  X  server;  returned  from
  68.                XOpenDisplay().
  69.  
  70.      drawable  Specifies the drawable.
  71.  
  72.      gc        Specifies the graphics context.
  73.  
  74.      x
  75.      y
  76.                Specify the x and y coordinates  of  the  baseline  starting
  77.                position  for  the  character, relative to the origin of the
  78.                specified drawable.
  79.  
  80.      string    Specifies the character string.
  81.  
  82.      length    Specifies the number of characters in string.
  83.  
  84. Output   : 
  85. Function : draw an 8-bit text string, foreground only.
  86. ********************************************************************************/
  87.  
  88. boolean
  89. X11SimpleTextClip( char* string, char* Xtempstr, int length, int* x, int* y )
  90. {
  91.   int nWidth;
  92.   int nNewWidth;
  93.  
  94.   nWidth = TextLength(DG.drp,Xtempstr,length);
  95.   if( *x+nWidth>DG.vWinWidth ){ /* shave off some characters at the end of the string */
  96.     int vNewLength = length;
  97.  
  98.     if( length==1 )
  99.       return FALSE;
  100.     nNewWidth = DG.vWinWidth-*x;
  101.     vNewLength = (int)(length*nNewWidth/nWidth);
  102.     while( TextLength(DG.drp,Xtempstr,vNewLength)>nNewWidth && vNewLength>0 ) {
  103.       vNewLength--;
  104.     }
  105.     if( !vNewLength )
  106.       return FALSE;
  107.     
  108.     length = vNewLength;
  109.     Xtempstr[length] = 0;
  110.   }
  111.   if( *y-DG.drp->Font->tf_Baseline<0 ){ 
  112.     return FALSE; /* The simple solution.. */
  113.   }
  114.   if( *y>DG.vWinHeight ){ 
  115.     return FALSE; /* The simple solution.. */
  116.   }
  117.   if( *x<0 ){ /* shave off some characters in the front of the string */
  118.     int vNewLength;
  119.     int vAdd;
  120.     
  121.     vNewLength = (int)(length*-*x/nWidth);
  122.     if( !vNewLength ){
  123.       vNewLength = 1;
  124.     }
  125.     while( (vAdd = TextLength(DG.drp,Xtempstr,vNewLength))<-*x && vNewLength>0 ) {
  126.       vNewLength++;
  127.     }
  128.     if( vNewLength>length )
  129.       return FALSE;
  130.     length -= vNewLength;
  131.     *x += vAdd;
  132.     strncpy(Xtempstr,&string[vNewLength],length);
  133.     Xtempstr[length] = 0;
  134.   }
  135.  
  136.   return TRUE;
  137. }
  138.  
  139. XDrawString( Display* d,
  140.          Drawable win,
  141.          GC gc,
  142.          int x,
  143.          int y,
  144.          char* string,
  145.          int length )
  146. { 
  147.   char Xtempstr[256];
  148.   struct IntuiText itext;
  149.  
  150.   strncpy(Xtempstr,string,length);
  151.   Xtempstr[length] = 0;
  152.  
  153. #ifdef DEBUGXEMUL_ENTRY
  154.   if( !bIgnoreText )
  155.  
  156.   if( bSkipText )
  157.     return;
  158. #endif
  159.   if( win!=DG.vPrevWindow )
  160.     if( !(DG.drp=setup_win(win)) )
  161.       return;
  162. #if 1
  163.   if( gc!=vPrevGC )
  164.     setup_gc(gc);
  165. #endif
  166.  
  167.   if( X11Drawables[win]==X11WINDOW ){
  168.     x -= X11Windows[X11DrawablesMap[win]].RelX;
  169.     y -= X11Windows[X11DrawablesMap[win]].RelY;
  170. #if 0
  171. /* def OPTDBG */
  172.     printf("(drawing)XDrawString [%s] to %d (%d %d) -> (%d %d) rel %d %d\n",Xtempstr,win,x,y,DG.vWinX+x,DG.vWinY+y,X11Windows[X11DrawablesMap[win]].RelX,X11Windows[X11DrawablesMap[win]].RelY); 
  173. #endif
  174.   }
  175.  
  176.   if( x>DG.vWinWidth || length<1 || !string )
  177.     return;
  178.  
  179.   if( gc->values.font /*&&!X11muiapp*/ ){
  180.     ULONG new;
  181.  
  182.     struct TextFont *tf = (struct TextFont*)((sFont*)gc->values.font)->tfont;
  183.     struct TextAttr *tattr = (struct TextAttr*)((sFont*)gc->values.font)->tattr;
  184.  
  185.     SetFont(DG.drp,tf);
  186.     new = SetSoftStyle(DG.drp,tattr->ta_Style ^ tf->tf_Style,(FSF_BOLD|FSF_UNDERLINED|FSF_ITALIC));
  187.  
  188. /*    if(tf->tf_Flags==42||tf==(struct TextFont*)DG.X11GC->values.font)StripFont(tf);*/
  189.   }
  190.  
  191. #ifndef DOCLIPPING
  192.   /* if I am not using intuition clipping I have to clip the text myself */
  193.   if( !X11SimpleTextClip(string,Xtempstr,length,&x,&y) )
  194.     return;
  195. #endif
  196.  
  197.   itext.IText = (char *)Xtempstr;
  198.   itext.LeftEdge = 0;
  199.   itext.TopEdge = 0;
  200. #if 0
  201.   if( gc->values.function==GXinvert || gc->values.function==GXxor ){
  202.     itext.DrawMode = COMPLEMENT;
  203.   } else /* if( gc->values.background==X11DrawablesBackground[win] ){*/
  204.     itext.DrawMode = JAM1;
  205. #else
  206.   itext.DrawMode = X11FunctionMapping[gc->values.function];
  207. #endif
  208.   itext.ITextFont = NULL;
  209.   itext.NextText = NULL;
  210.   itext.FrontPen = gc->values.foreground;
  211.   itext.BackPen = gc->values.background;
  212.  
  213. #if 0
  214.   if( gc->values.foreground == X11DrawablesBackground[win] )
  215.     printf("Invisible?\n");
  216.  
  217.   itext.DrawMode = JAM2;
  218. #endif
  219.  
  220.   PrintIText(DG.drp,&itext,DG.vWinX+x,DG.vWinY+y-DG.drp->Font->tf_Baseline);
  221. }
  222.  
  223. /********************************************************************************
  224. Function : XDrawImageString()
  225. Author   : Terje Pedersen
  226. Input    : 
  227.      display   Specifies  a  connection  to  an  X  server;  returned  from
  228.                XOpenDisplay().
  229.  
  230.      drawable  Specifies the drawable.
  231.  
  232.      gc        Specifies the graphics context.
  233.  
  234.      x
  235.      y
  236.                Specify the x and y coordinates  of  the  baseline  starting
  237.                position  for  the  image  text  character,  relative to the
  238.                origin of the specified drawable.
  239.  
  240.      string    Specifies the character string.
  241.  
  242.      length    Specifies the number of characters in the string argument.
  243.  
  244. Output   : 
  245. Function : draw 8-bit image text characters.
  246. ********************************************************************************/
  247.  
  248. XDrawImageString( Display* display,
  249.           Window win,
  250.           struct _XGC* gc,
  251.           int x,
  252.           int y,
  253.           char* string,
  254.           int length )
  255. {
  256.   char Xtempstr[256];
  257.   struct IntuiText itext;
  258.   int origx,origy;
  259.  
  260. #ifdef DEBUGXEMUL_ENTRY
  261.   if( !bIgnoreText )
  262.     printf("(events)XDrawImageString %d,%d %s (%d)in window %d\n",x,y,string,length,(int)win);
  263.   if( bSkipText )
  264.     return;
  265. #endif 
  266.   if( win!=DG.vPrevWindow )
  267.     if( !(DG.drp=setup_win(win)) )
  268.       return;
  269.   if( gc!=vPrevGC )
  270.     setup_gc(gc);
  271.  
  272.   if( gc->values.font /*&&!X11muiapp*/ ){
  273.     struct TextFont *tf = (struct TextFont*)((sFont*)gc->values.font)->tfont;
  274. /*
  275.     struct TextAttr *tattr = (struct TextAttr*)((sFont*)gc->values.font)->tattr;
  276. */
  277.     SetFont(DG.drp,tf);
  278. /*    if(tf->tf_Flags==42||tf==(struct TextFont*)DG.X11GC->values.font)StripFont(tf);*/
  279.   }
  280.   origx = DG.vWinX+x;
  281.   origy = DG.vWinY+y-DG.drp->Font->tf_Baseline;
  282.  
  283.   if( length<1 || !string ) {
  284.     /*printf("zero length string in xdrawimagestring\n");*/ 
  285.     return;
  286.   }
  287.  
  288.   strncpy(Xtempstr,string,length);
  289.   Xtempstr[length] = 0;
  290.  
  291. #ifndef DOCLIPPING
  292.   /* if I am not using intuition clipping I have to clip the text myself */
  293.   if( !X11SimpleTextClip(string,Xtempstr,length,&x,&y) )
  294.     return;
  295. #endif
  296.  
  297.   itext.IText = Xtempstr;
  298.   itext.LeftEdge = 0;
  299.   itext.TopEdge = 0;
  300. #if 1
  301.   if( gc->values.function==GXinvert || gc->values.function==GXxor ){
  302.     itext.DrawMode = COMPLEMENT;
  303.   } else {
  304.     itext.DrawMode = JAM2;
  305.   }
  306. #else
  307.   itext.DrawMode = X11FunctionMapping[gc->values.function];
  308. #endif
  309.   itext.ITextFont = NULL;
  310.   itext.NextText = NULL;
  311.   itext.FrontPen = gc->values.foreground;
  312.   itext.BackPen = gc->values.background;
  313.   PrintIText(DG.drp,&itext,origx,origy);
  314. }
  315.  
  316. /********************************************************************************
  317. Function : XDrawText16()
  318. Author   : Terje Pedersen
  319. Input    : 
  320.      display   Specifies  a  connection  to  an  X  server;  returned  from
  321.                XOpenDisplay().
  322.  
  323.      drawable  Specifies the drawable.
  324.  
  325.      gc        Specifies the graphics context.
  326.  
  327.      x
  328.      y
  329.                Specify the x and y coordinates  of  the  baseline  starting
  330.                position  for  the initial string, relative to the origin of
  331.                the specified drawable.
  332.  
  333.      items     Specifies a pointer to an array of text items using two-byte
  334.                characters.
  335.  
  336.      nitems    Specifies the number of text items in the array.
  337.  
  338. Output   : 
  339. Function : draw 16-bit polytext strings.
  340. ********************************************************************************/
  341.  
  342. XDrawText16( Display* display,
  343.          Drawable drawable,
  344.          GC gc,
  345.          int x,
  346.          int y,
  347.          XTextItem16* items,
  348.          int nitems )
  349. {
  350. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  351.   printf("WARNING: XDrawText16\n");
  352. #endif
  353.  
  354.   return(0);
  355. }
  356.  
  357. /********************************************************************************
  358. Function : XDrawString16()
  359. Author   : Terje Pedersen
  360. Input    : 
  361.      display   Specifies  a  connection  to  an  X  server;  returned  from
  362.                XOpenDisplay().
  363.  
  364.      drawable  Specifies the drawable.
  365.  
  366.      gc        Specifies the graphics context.
  367.  
  368.      x
  369.      y
  370.                Specify the x and y coordinates  of  the  baseline  starting
  371.                position  for  the  character, relative to the origin of the
  372.                specified drawable.
  373.  
  374.      string    Specifies the character string.  Characters  are  two  bytes
  375.                wide.
  376.  
  377.      length    Specifies the number of characters in string.
  378.  
  379. Output   : 
  380. Function : draw two-byte text strings.
  381. ********************************************************************************/
  382.  
  383. XDrawString16( Display* display,
  384.            Drawable drawable,
  385.            GC gc,
  386.            int x,
  387.            int y,
  388.            char* string,
  389.            int length )
  390. {
  391. #if (DEBUGXEMUL_ENTRY)
  392.   if( !bIgnoreText )
  393.     printf("XDrawString16\n");
  394. #endif
  395.   XDrawString(display,drawable,gc,x,y,string,length);
  396.  
  397.   return(0);
  398. }
  399.  
  400. /********************************************************************************
  401. Function : XDrawImageString16()
  402. Author   : Terje Pedersen
  403. Input    : 
  404.      display   Specifies a connection to an X server; returned from
  405.                XOpenDisplay().
  406.  
  407.      drawable  Specifies the drawable.
  408.  
  409.      gc        Specifies the graphics context.
  410.  
  411.      x
  412.      y
  413.                Specify the x and y coordinates of the baseline starting
  414.                position for the image text character, relative to the
  415.                origin of the specified drawable.
  416.  
  417.      string    Specifies the character string.
  418.  
  419.      length    Specifies the number of characters in the string argument.
  420.  
  421. Output   : 
  422. Function : draw 16-bit image text characters.
  423. ********************************************************************************/
  424.  
  425. XDrawImageString16( Display* display,
  426.             Drawable win,
  427.             GC gc,
  428.             int x,
  429.             int y,
  430.             char* string,
  431.             int length )
  432. {
  433. #ifdef DEBUGXEMUL_ENTRY
  434.   if( !bIgnoreText )
  435.     printf("XDrawImageString16\n");
  436. #endif
  437.   XDrawImageString(display,win,gc,x,y,string,length);
  438.  
  439.   return(0);
  440. }
  441.  
  442.  
  443. /********************************************************************************
  444. Function : XDrawText()
  445. Author   : Terje Pedersen
  446. Input    : 
  447.      display   Specifies  a  connection  to  an  X  server;  returned  from
  448.                XOpenDisplay().
  449.  
  450.      drawable  Specifies the drawable.
  451.  
  452.      gc        Specifies the graphics context.
  453.  
  454.      x
  455.      y
  456.                Specify the x and y coordinates  of  the  baseline  starting
  457.                position  for  the initial string, relative to the origin of
  458.                the specified drawable.
  459.  
  460.      items     Specifies a pointer to an array of text items.
  461.  
  462.      nitems    Specifies the number of text items in the items array.
  463.  
  464. Output   : 
  465. Function : draw 8-bit polytext strings.
  466. ********************************************************************************/
  467.  
  468. XDrawText( Display* display,
  469.        Drawable drawable,
  470.        GC gc,
  471.        int x,
  472.        int y,
  473.        XTextItem* items,
  474.        int nitems )
  475. {
  476. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  477.   printf("WARNING: XDrawText\n");
  478. #endif
  479.  
  480.   return(0);
  481. }
  482.  
  483. XTextExtents16(font_struct, string, nchars, direction_return,
  484.                font_ascent_return, font_descent_return, overall_return)
  485.      XFontStruct *font_struct;
  486.      XChar2b *string;
  487.      int nchars;
  488.      int *direction_return;
  489.      int *font_ascent_return, *font_descent_return;
  490.      XCharStruct *overall_return;
  491. {/*          File 'auxtext.o' */
  492. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  493.   printf("WARNING: XTextExtents16\n");
  494. #endif
  495.   return(0);
  496. }
  497.